home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 16 / CU Amiga Magazine's Super CD-ROM 16 (1997-10-16)(EMAP Images)(GB)[!][issue 1997-11].iso / CUCD / Graphics / Ghostscript / source / gdevpdfm.c < prev    next >
C/C++ Source or Header  |  1997-07-08  |  22KB  |  738 lines
  1. /* Copyright (C) 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevpdfm.c */
  20. /* pdfmark processing for PDF-writing driver */
  21. #include "memory_.h"
  22. #include "string_.h"
  23. #include "gx.h"
  24. #include "gserrors.h"
  25. #include "gsutil.h"        /* for bytes_compare */
  26. #include "gdevpdfx.h"
  27. #include "scanchar.h"
  28.  
  29. /* GC descriptors */
  30. private_st_pdf_article();
  31. private_st_pdf_named_dest();
  32.  
  33. /*
  34.  * The pdfmark pseudo-parameter indicates the occurrence of a pdfmark
  35.  * operator in the input file.  Its "value" is the arguments of the operator,
  36.  * passed through essentially unchanged:
  37.  *    (key, value)*, CTM, type
  38.  */
  39.  
  40. /*
  41.  * Define the pdfmark types we know about.
  42.  */
  43. #define pdfmark_proc(proc)\
  44.   int proc(P4(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,\
  45.           const gs_matrix *pctm))
  46. typedef struct pdfmark_name_s {
  47.   const char *mname;
  48.   pdfmark_proc((*proc));
  49. } pdfmark_name;
  50. private pdfmark_proc(pdfmark_ANN);
  51. private pdfmark_proc(pdfmark_LNK);
  52. private pdfmark_proc(pdfmark_OUT);
  53. private pdfmark_proc(pdfmark_ARTICLE);
  54. private pdfmark_proc(pdfmark_DEST);
  55. private pdfmark_proc(pdfmark_PS);
  56. private pdfmark_proc(pdfmark_PAGES);
  57. private pdfmark_proc(pdfmark_PAGE);
  58. private pdfmark_proc(pdfmark_DOCINFO);
  59. private pdfmark_proc(pdfmark_DOCVIEW);
  60. private const pdfmark_name mark_names[] = {
  61.   { "ANN", pdfmark_ANN },
  62.   { "LNK", pdfmark_LNK },
  63.   { "OUT", pdfmark_OUT },
  64.   { "ARTICLE", pdfmark_ARTICLE },
  65.   { "DEST", pdfmark_DEST },
  66.   { "PS", pdfmark_PS },
  67.   { "PAGES", pdfmark_PAGES },
  68.   { "PAGE", pdfmark_PAGE },
  69.   { "DOCINFO", pdfmark_DOCINFO },
  70.   { "DOCVIEW", pdfmark_DOCVIEW },
  71.   { 0, 0 }
  72. };
  73.  
  74. /* Compare a C string and a gs_param_string. */
  75. bool
  76. pdf_key_eq(const gs_param_string *pcs, const char *str)
  77. {    return (strlen(str) == pcs->size &&
  78.         !strncmp(str, (const char *)pcs->data, pcs->size));
  79. }
  80.  
  81. /* Process a pdfmark. */
  82. int
  83. pdfmark_process(gx_device_pdf *pdev, const gs_param_string_array *pma)
  84. {    const gs_param_string *pts = &pma->data[pma->size - 1];
  85.     gs_matrix ctm;
  86.     int i;
  87.  
  88.     if ( pma->size & 1 ||
  89.          sscanf((const char *)pts[-1].data, "[%g %g %g %g %g %g]",
  90.             &ctm.xx, &ctm.xy, &ctm.yx, &ctm.yy, &ctm.tx, &ctm.ty) != 6
  91.        )
  92.       return_error(gs_error_rangecheck);
  93.     gs_matrix_scale(&ctm, 1.0 / pdev->scale.x, 1.0 / pdev->scale.y, &ctm);
  94.     ctm.tx /= pdev->scale.x;
  95.     ctm.ty /= pdev->scale.y;
  96.     for ( i = 0; mark_names[i].mname != 0; ++i )
  97.       if ( pdf_key_eq(pts, mark_names[i].mname) )
  98.         return (*mark_names[i].proc)(pdev, pma->data, pma->size - 2, &ctm);
  99.     return 0;
  100. }
  101.  
  102. /* Find a key in a dictionary. */
  103. private bool
  104. pdfmark_find_key(const char *key, const gs_param_string *pairs, uint count,
  105.   gs_param_string *pstr)
  106. {    uint i;
  107.     for ( i = 0; i < count; i += 2 )
  108.       if ( pdf_key_eq(&pairs[i], key) )
  109.         { *pstr = pairs[i + 1];
  110.           return true;
  111.         }
  112.     pstr->data = 0;
  113.     pstr->size = 0;
  114.     return false;
  115. }
  116.  
  117. /* Get the ID for a page referenced by number or as /Next or /Prev. */
  118. /* The result may be 0 if the page number is 0 or invalid. */
  119. private long
  120. pdfmark_page_id(gx_device_pdf *pdev, int *ppage, const gs_param_string *pnstr)
  121. {    int page = pdev->next_page + 1;
  122.  
  123.     if ( pnstr->data == 0 )
  124.       ;
  125.     else if ( pdf_key_eq(pnstr, "/Next") )
  126.       ++page;
  127.     else if ( pdf_key_eq(pnstr, "/Prev") )
  128.       --page;
  129.     else if ( sscanf((const char *)pnstr->data, "%d", &page) != 1 )    /****** WRONG, assumes null terminator ******/
  130.       page = 0;
  131.     *ppage = page;
  132.     return pdf_page_id(pdev, page);
  133. }
  134.  
  135. /* Construct a destination string specified by /Page and/or /View. */
  136. /* Return 0 if none (but still fill in a default), 1 if present, */
  137. /* <0 if error. */
  138. private int
  139. pdfmark_make_dest(char dstr[max_dest_string], gx_device_pdf *pdev,
  140.   const gs_param_string *pairs, uint count)
  141. {    gs_param_string page_string, view_string;
  142.     int page;
  143.     bool present =
  144.       pdfmark_find_key("Page", pairs, count, &page_string) |
  145.         pdfmark_find_key("View", pairs, count, &view_string);
  146.     long page_id = pdfmark_page_id(pdev, &page, &page_string);
  147.     int len;
  148.  
  149.     if ( view_string.size == 0 )
  150.       param_string_from_string(view_string, "[/XYZ 0 0 1]");
  151.     if ( page_id == 0 )
  152.       strcpy(dstr, "[null ");
  153.     else
  154.       sprintf(dstr, "[%ld 0 R ", page_id);
  155.     len = strlen(dstr);
  156.     if ( len + view_string.size > max_dest_string )
  157.       return_error(gs_error_limitcheck);
  158.     if ( view_string.data[0] != '[' ||
  159.          view_string.data[view_string.size - 1] != ']'
  160.        )
  161.       return_error(gs_error_rangecheck);
  162.     memcpy(dstr + len, view_string.data + 1, view_string.size - 1);
  163.     dstr[len + view_string.size - 1] = 0;
  164.     return present;
  165. }
  166.  
  167. /* Write pairs for a dictionary. */
  168. private void
  169. pdfmark_write_pair(stream *s, const gs_param_string *pair)
  170. {    pputc(s, '/');
  171.     pwrite(s, pair->data, pair->size);
  172.     pputc(s, ' ');
  173.     pwrite(s, pair[1].data, pair[1].size);
  174.     pputc(s, '\n');
  175. }
  176.  
  177. /* Scan a Rect value. */
  178. private int
  179. pdfmark_scan_rect(gs_rect *prect, const gs_param_string *str,
  180.   const gs_matrix *pctm)
  181. {    uint size = str->size;
  182.     double v[4];
  183. #define max_rect_string_size 100
  184.     char chars[max_rect_string_size + 3];
  185.     int end_check;
  186.  
  187.     if ( str->size > max_rect_string_size )
  188.       return_error(gs_error_limitcheck);
  189.     memcpy(chars, str->data, size);
  190.     strcpy(chars + size, " 0");
  191.     if ( sscanf(chars, "[%lg %lg %lg %lg]%d",
  192.             &v[0], &v[1], &v[2], &v[3], &end_check) != 5
  193.        )
  194.       return_error(gs_error_rangecheck);
  195.     gs_point_transform(v[0], v[1], pctm, &prect->p);
  196.     gs_point_transform(v[2], v[3], pctm, &prect->q);
  197.     return 0;
  198. }
  199.  
  200. /* Write a Rect value. */
  201. private void
  202. pdfmark_write_rect(stream *s, const char *key, const gs_rect *prect)
  203. {    pprints1(s, "/%s ", key);
  204.     pprintg4(s, "[%g %g %g %g]\n",
  205.          prect->p.x, prect->p.y, prect->q.x, prect->q.y);
  206. }
  207.  
  208. /* Copy an annotation dictionary. */
  209. private int
  210. pdfmark_annot(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  211.   const gs_matrix *pctm, const char *subtype)
  212. {    stream *s = pdev->strm;
  213.     pdf_resource *pres;
  214.     int code = pdf_begin_aside(pdev, &pdev->annots, NULL, &pres);
  215.     bool subtype_present = false;
  216.     bool add_dest = false;
  217.     bool dest_present = false;
  218.     uint i;
  219.  
  220.     if ( code < 0 )
  221.       return code;
  222.     pres->rid = pdev->next_page;
  223.     pputs(s, "<< /Type /Annot\n");
  224.     for ( i = 0; i < count; i += 2 )
  225.       { const gs_param_string *pair = &pairs[i];
  226.         long src_pg;
  227.  
  228.         if ( pdf_key_eq(pair, "SrcPg") &&
  229.          sscanf((const char *)pair[1].data, "%ld", &src_pg) == 1
  230.            )
  231.           pres->rid = src_pg - 1;
  232.         else if ( pdf_key_eq(pair, "Page") || pdf_key_eq(pair, "View") )
  233.           add_dest = true;
  234.         /*
  235.          * For some unfathomable reason, PDF requires /A instead of
  236.          * /Action, and /S instead of /Subtype in the Action dictionary.
  237.          * Handle this here.
  238.          */
  239.         else if ( pdf_key_eq(pair, "Action") )
  240.           { const byte *astr = pair[1].data;
  241.             const uint asize = pair[1].size;
  242.         uint i;
  243.  
  244.         pputs(s, "/A ");
  245.         /* Search for the next occurrence of /Subtype. */
  246.         for ( i = 0; i < asize; ++i )
  247.           if ( asize - i > 8 && !memcmp(astr + i, "/Subtype", 8) &&
  248.                scan_char_decoder[astr[i + 8]] > ctype_name
  249.              )
  250.             { pputs(s, "/S");
  251.               i += 7;
  252.             }
  253.           else
  254.             pputc(s, astr[i]);
  255.             pputc(s, '\n');
  256.           }
  257.         else if ( pdf_key_eq(pair, "Rect") )
  258.           { gs_rect rect;
  259.  
  260.             code = pdfmark_scan_rect(&rect, pair + 1, pctm);
  261.         if ( code < 0 )
  262.           return code;
  263.         pdfmark_write_rect(s, "Rect", &rect);
  264.           }
  265.         else
  266.           { pdfmark_write_pair(s, pair);
  267.             if ( pdf_key_eq(pair, "Dest") )
  268.           dest_present = true;
  269.         else if ( pdf_key_eq(pair, "Subtype") )
  270.           subtype_present = true;
  271.           }
  272.       }
  273.     if ( add_dest && !dest_present )
  274.       { char dest[max_dest_string];
  275.         int code = pdfmark_make_dest(dest, pdev, pairs, count);
  276.         if ( code >= 0 )
  277.           pprints1(s, "/Dest %s\n", dest);
  278.       }
  279.     if ( !subtype_present )
  280.       pprints1(s, "/Subtype /%s ", subtype);
  281.     pputs(s, ">>\n");
  282.     pdf_end_aside(pdev);
  283.     return 0;
  284. }
  285.  
  286. /* ANN pdfmark */
  287. private int
  288. pdfmark_ANN(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  289.   const gs_matrix *pctm)
  290. {    return pdfmark_annot(pdev, pairs, count, pctm, "Text");
  291. }
  292.  
  293. /* LNK pdfmark (obsolescent) */
  294. private int
  295. pdfmark_LNK(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  296.   const gs_matrix *pctm)
  297. {    return pdfmark_annot(pdev, pairs, count, pctm, "Link");
  298. }
  299.  
  300. /* Save pairs in a string. */
  301. private bool
  302. pdf_key_member(const gs_param_string *pcs, const char **keys)
  303. {    const char **pkey;
  304.     for ( pkey = keys; *pkey != 0; ++pkey )
  305.       if ( pdf_key_eq(pcs, *pkey) )
  306.         return true;
  307.     return false;
  308. }
  309. private int
  310. pdfmark_save_edited_pairs(const gx_device_pdf *pdev,
  311.   const gs_param_string *pairs, uint count, const char **skip_keys,
  312.   const gs_param_string *add_pairs, uint add_count, gs_string *pstr)
  313. {    uint i, size;
  314.     byte *data;
  315.     byte *next;
  316.  
  317.     for ( i = 0, size = 0; i < count; i += 2 )
  318.       if ( !pdf_key_member(&pairs[i], skip_keys) )
  319.         size += pairs[i].size + pairs[i+1].size + 3;
  320.     for ( i = 0; i < add_count; i += 2 )
  321.       size += add_pairs[i].size + add_pairs[i+1].size + 3;
  322.     if ( pstr->data == 0 )
  323.       data = gs_alloc_string(pdev->pdf_memory, size, "pdfmark_save_pairs");
  324.     else
  325.       data = gs_resize_string(pdev->pdf_memory, pstr->data, pstr->size,
  326.                   size, "pdfmark_save_pairs");
  327.     if ( data == 0 )
  328.       return_error(gs_error_VMerror);
  329.     next = data;
  330.     for ( i = 0; i < count; i += 2 )
  331.       if ( !pdf_key_member(&pairs[i], skip_keys) )
  332.         { uint len;
  333.           *next++ = '/';
  334.           memcpy(next, pairs[i].data, len = pairs[i].size);
  335.           next += len;
  336.           *next++ = ' ';
  337.           memcpy(next, pairs[i+1].data, len = pairs[i+1].size);
  338.           next += len;
  339.           *next++ = '\n';
  340.         }
  341.     for ( i = 0; i < add_count; i += 2 )
  342.       { uint len;
  343.         *next++ = '/';
  344.         memcpy(next, add_pairs[i].data, len = add_pairs[i].size);
  345.         next += len;
  346.         *next++ = ' ';
  347.         memcpy(next, add_pairs[i+1].data, len = add_pairs[i+1].size);
  348.         next += len;
  349.         *next++ = '\n';
  350.       }
  351.     pstr->data = data;
  352.     pstr->size = size;
  353.     return 0;
  354. }
  355. static const char *no_skip_pairs[] = { 0 };
  356. #define pdfmark_save_pairs(pdev, pairs, count, pstr)\
  357.   pdfmark_save_edited_pairs(pdev, pairs, count, no_skip_pairs, NULL, 0, pstr)
  358.  
  359. /* Write out one node of the outline tree. */
  360. private int
  361. pdfmark_write_outline(gx_device_pdf *pdev, pdf_outline_node *pnode,
  362.   long next_id)
  363. {    stream *s = pdev->strm;
  364.  
  365.     pdf_close_contents(pdev, false);
  366.     pdf_open_obj(pdev, pnode->id);
  367.     pputs(s, "<< ");
  368.     pdf_write_saved_string(pdev, &pnode->action_string);
  369.     if ( pnode->count )
  370.       pprintd1(s, "/Count %d ", pnode->count);
  371.     pprintld1(s, "/Parent %ld 0 R\n", pnode->parent_id);
  372.     if ( pnode->prev_id )
  373.       pprintld1(s, "/Prev %ld 0 R\n", pnode->prev_id);
  374.     if ( next_id )
  375.       pprintld1(s, "/Next %ld 0 R\n", next_id);
  376.     if ( pnode->first_id )
  377.       pprintld2(s, "/First %ld 0 R /Last %ld 0 R\n",
  378.             pnode->first_id, pnode->last_id);
  379.     pputs(s, ">>\n");
  380.     pdf_end_obj(pdev);
  381.     return 0;
  382. }
  383.  
  384. /* Adjust the parent's count when writing an outline node. */
  385. private void
  386. pdfmark_adjust_parent_count(pdf_outline_level *plevel)
  387. {    pdf_outline_level *parent = plevel - 1;
  388.     int count = plevel->last.count;
  389.  
  390.     if ( count > 0 )
  391.       { if ( parent->last.count < 0 )
  392.           parent->last.count -= count;
  393.         else
  394.           parent->last.count += count;
  395.       }
  396. }
  397.  
  398. /* Close the current level of the outline tree. */
  399. int
  400. pdfmark_close_outline(gx_device_pdf *pdev)
  401. {    int depth = pdev->outline_depth;
  402.     pdf_outline_level *plevel = &pdev->outline_levels[depth];
  403.     int code;
  404.  
  405.     code = pdfmark_write_outline(pdev, &plevel->last, 0);
  406.     if ( code < 0 )
  407.       return code;
  408.     if ( depth > 0 )
  409.       { plevel[-1].last.last_id = plevel->last.id;
  410.         pdfmark_adjust_parent_count(plevel);
  411.         --plevel;
  412.         if ( plevel->last.count < 0 )
  413.           pdev->closed_outline_depth--;
  414.         pdev->outline_depth--;
  415.       }
  416.     return 0;
  417. }
  418.  
  419. /* OUT pdfmark */
  420. private int
  421. pdfmark_OUT(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  422.   const gs_matrix *pctm)
  423. {    int depth = pdev->outline_depth;
  424.     pdf_outline_level *plevel = &pdev->outline_levels[depth];
  425.     int sub_count = 0;
  426.     uint i;
  427.     pdf_outline_node node;
  428.     int code;
  429.  
  430.     for ( i = 0; i < count; i += 2 )
  431.       { const gs_param_string *pair = &pairs[i];
  432.         if ( pdf_key_eq(pair, "Count") )
  433.           sscanf((const char *)pair[1].data, "%d", &sub_count);
  434.       }
  435.     if ( sub_count != 0 && depth == max_outline_depth - 1 )
  436.       return_error(gs_error_limitcheck);
  437.     node.action_string.data = 0;
  438.     { static const char *skip_out[] = { "Count", 0 };
  439.       code = pdfmark_save_edited_pairs(pdev, pairs, count, skip_out,
  440.                        NULL, 0, &node.action_string);
  441.       if ( code < 0 )
  442.         return code;
  443.     }
  444.     if ( pdev->outlines_id == 0 )
  445.       pdev->outlines_id = pdf_obj_ref(pdev);
  446.     node.id = pdf_obj_ref(pdev);
  447.     node.parent_id =
  448.       (depth == 0 ? pdev->outlines_id : plevel[-1].last.id);
  449.     node.prev_id = plevel->last.id;
  450.     node.first_id = node.last_id = 0;
  451.     node.count = sub_count;
  452.     /* Add this node to the outline at the current level. */
  453.     if ( plevel->first.id == 0 )
  454.       { /* First node at this level. */
  455.         if ( depth > 0 )
  456.           plevel[-1].last.first_id = node.id;
  457.         node.prev_id = 0;
  458.         plevel->first = node;
  459.       }
  460.     else
  461.       { /* Write out the previous node. */
  462.         if ( depth > 0 )
  463.           pdfmark_adjust_parent_count(plevel);
  464.         pdfmark_write_outline(pdev, &plevel->last, node.id);
  465.       }
  466.     plevel->last = node;
  467.     plevel->left--;
  468.     if ( !pdev->closed_outline_depth )
  469.       pdev->outlines_open++;
  470.     /* If this node has sub-nodes, descend one level. */
  471.     if ( sub_count != 0 )
  472.       { pdev->outline_depth++;
  473.         ++plevel;
  474.         plevel->left = (sub_count > 0 ? sub_count : -sub_count);
  475.         plevel->first.id = 0;
  476.         if ( sub_count < 0 )
  477.           pdev->closed_outline_depth++;
  478.       }
  479.     else
  480.       { while ( (depth = pdev->outline_depth) > 0 &&
  481.             pdev->outline_levels[depth].left == 0
  482.           )
  483.           pdfmark_close_outline(pdev);
  484.       }
  485.     return 0;
  486. }
  487.  
  488. /* Write an article bead. */
  489. int
  490. pdfmark_write_article(gx_device_pdf *pdev, const pdf_bead *pbead)
  491. {    stream *s = pdev->strm;
  492.  
  493.     pdf_open_obj(pdev, pbead->id);
  494.     pprintld3(s,
  495.           "<<\n/T %ld 0 R\n/V %ld 0 R\n/N %ld 0 R\n",
  496.           pbead->article_id, pbead->prev_id, pbead->next_id);
  497.     pprints1(s, "/Dest %s\n", pbead->dest);
  498.     pdfmark_write_rect(s, "R", &pbead->rect);
  499.     pputs(s, ">>\n");
  500.     return pdf_end_obj(pdev);
  501. }
  502.  
  503. /* ARTICLE pdfmark */
  504. private int
  505. pdfmark_ARTICLE(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  506.   const gs_matrix *pctm)
  507. {    gs_param_string title;
  508.     gs_param_string rectstr;
  509.     gs_rect rect;
  510.     long bead_id;
  511.     pdf_article *part;
  512.     int code;
  513.  
  514.     if ( !pdfmark_find_key("Title", pairs, count, &title) ||
  515.          !pdfmark_find_key("Rect", pairs, count, &rectstr)
  516.        )
  517.       return_error(gs_error_rangecheck);
  518.     if ( (code = pdfmark_scan_rect(&rect, &rectstr, pctm)) < 0 )
  519.       return code;
  520.     /****** Should save other keys for Info dictionary ******/
  521.     pdf_close_contents(pdev, false);
  522.  
  523.     /* Find the article with this title, or create one. */
  524.     bead_id = pdf_obj_ref(pdev);
  525.     for ( part = pdev->articles; part != 0; part = part->next )
  526.       if ( !bytes_compare(part->title.data, part->title.size,
  527.                   title.data, title.size) )
  528.         break;
  529.     if ( part == 0 )
  530.       { /* Create the article. */
  531.         stream *s = pdev->strm;
  532.         byte *str;
  533.  
  534.         part = gs_alloc_struct(pdev->pdf_memory, pdf_article,
  535.                    &st_pdf_article, "pdfmark_ARTICLE");
  536.         str = gs_alloc_string(pdev->pdf_memory, title.size,
  537.                   "article title");
  538.         if ( part == 0 || str == 0 )
  539.           return_error(gs_error_VMerror);
  540.         part->next = pdev->articles;
  541.         pdev->articles = part;
  542.         memcpy(str, title.data, title.size);
  543.         part->title.data = str;
  544.         part->title.size = title.size;
  545.         part->id = pdf_begin_obj(pdev);
  546.         part->first.id = part->last.id = 0;
  547.         pprintld1(s, "<< /F %ld 0 R >>\n", bead_id);
  548.         pdf_end_obj(pdev);
  549.       }
  550.  
  551.     /* Add the bead to the article. */
  552.     /* This is similar to what we do for outline nodes. */
  553.     if ( part->last.id == 0 )
  554.       { part->first.next_id = bead_id;
  555.         part->last.id = part->first.id;
  556.       }
  557.     else
  558.       { part->last.next_id = bead_id;
  559.         pdfmark_write_article(pdev, &part->last);
  560.       }
  561.     part->last.prev_id = part->last.id;
  562.     part->last.id = bead_id;
  563.     part->last.article_id = part->id;
  564.     part->last.next_id = 0;
  565.     part->last.rect = rect;
  566.     pdfmark_make_dest(part->last.dest, pdev, pairs, count);
  567.     if ( part->first.id == 0 )
  568.       { /* This is the first bead of the article. */
  569.         part->first = part->last;
  570.         part->last.id = 0;
  571.       }
  572.  
  573.     return 0;
  574. }
  575.  
  576. /* DEST pdfmark */
  577. private int
  578. pdfmark_DEST(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  579.   const gs_matrix *pctm)
  580. {    char dest[max_dest_string];
  581.     gs_param_string key;
  582.     pdf_named_dest *pnd;
  583.     byte *str;
  584.  
  585.     if ( !pdfmark_find_key("Dest", pairs, count, &key) ||
  586.          !pdfmark_make_dest(dest, pdev, pairs, count)
  587.        )
  588.       return_error(gs_error_rangecheck);
  589.     pnd = gs_alloc_struct(pdev->pdf_memory, pdf_named_dest,
  590.                   &st_pdf_named_dest, "pdfmark_DEST");
  591.     str = gs_alloc_string(pdev->pdf_memory, key.size,
  592.                   "named_dest key");
  593.     if ( pnd == 0 || str == 0 )
  594.       return_error(gs_error_VMerror);
  595.     pnd->next = pdev->named_dests;
  596.     memcpy(str, key.data, key.size);
  597.     pnd->key.data = str;
  598.     pnd->key.size = key.size;
  599.     strcpy(pnd->dest, dest);
  600.     pdev->named_dests = pnd;
  601.     return 0;
  602. }
  603.  
  604. /* Write the contents of pass-through code. */
  605. /* We are inside the stream dictionary. */
  606. private int
  607. pdfmark_write_ps(gx_device_pdf *pdev, const gs_param_string *psource)
  608. {    stream *s = pdev->strm;
  609.     long length_id = pdf_obj_ref(pdev);
  610.     long start_pos, length;
  611.  
  612.     pprintld1(s, " /Length %ld 0 R >> stream\n", length_id);
  613.     start_pos = stell(s);
  614.     if ( psource->size < 2 || psource->data[0] != '(' ||
  615.          psource->data[psource->size - 1] != ')'
  616.        )
  617.       lprintf1("bad PS passthrough: %s\n", psource->data);
  618.     else
  619.       { /****** SHOULD REMOVE ESCAPES ******/
  620.         pwrite(s, psource->data + 1, psource->size - 2);
  621.       }
  622.     pputs(s, "\n");
  623.     length = stell(s) - start_pos;
  624.     pputs(s, "endstream\n");
  625.     pdf_end_obj(pdev);
  626.     pdf_open_obj(pdev, length_id);
  627.     pprintld1(s, "%ld\n", length);
  628.     pdf_end_obj(pdev);
  629.     return 0;
  630. }
  631.  
  632. /* PS pdfmark */
  633. private int
  634. pdfmark_PS(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  635.   const gs_matrix *pctm)
  636. {    stream *s = pdev->strm;
  637.     gs_param_string source;
  638.     gs_param_string level1;
  639.  
  640.     if ( !pdfmark_find_key("DataSource", pairs, count, &source) )
  641.       return_error(gs_error_rangecheck);
  642.     pdfmark_find_key("Level1", pairs, count, &level1);
  643.     if ( level1.data == 0 && source.size <= 100 )
  644.       { /* Insert the PostScript code in-line */
  645.         int code = pdf_open_contents(pdev, pdf_in_stream);
  646.         if ( code < 0 )
  647.           return code;
  648.         pwrite(s, source.data, source.size);
  649.         pputs(s, " PS\n");
  650.       }
  651.     else
  652.       { /* Put the PostScript code in a resource. */
  653.         pdf_resource *pres;
  654.         int code = pdf_begin_resource(pdev, resourceXObject, &pres);
  655.  
  656.         if ( code < 0 )
  657.           return code;
  658.         pputs(s, " /Subtype /PS");
  659.         if ( level1.data != 0 )
  660.           { long level1_id = pdf_obj_ref(pdev);
  661.         pprintld1(s, " /Level1 %ld 0 R", level1_id);
  662.         pdfmark_write_ps(pdev, &source);
  663.         pdf_open_obj(pdev, level1_id);
  664.         pputs(s, "<<");
  665.         pdfmark_write_ps(pdev, &level1);
  666.           }
  667.         else
  668.           pdfmark_write_ps(pdev, &source);
  669.         code = pdf_open_contents(pdev, pdf_in_stream);
  670.         if ( code < 0 )
  671.           return code;
  672.         pprintld1(s, "/R%ld Do\n", pres->id);
  673.       }
  674.     return 0;
  675. }
  676.  
  677. /* PAGES pdfmark */
  678. private int
  679. pdfmark_PAGES(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  680.   const gs_matrix *pctm)
  681. {    return pdfmark_save_pairs(pdev, pairs, count, &pdev->pages_string);
  682. }
  683.  
  684. /* PAGE pdfmark */
  685. private int
  686. pdfmark_PAGE(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  687.   const gs_matrix *pctm)
  688. {    return pdfmark_save_pairs(pdev, pairs, count, &pdev->page_string);
  689. }
  690.  
  691. /* DOCINFO pdfmark */
  692. private int
  693. pdfmark_DOCINFO(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  694.   const gs_matrix *pctm)
  695. {    stream *s = pdev->strm;
  696.     long info_id;
  697.     uint i;
  698.  
  699.     if ( pdev->context != pdf_in_none &&
  700.          pdev->next_contents_id == max_contents_ids
  701.        )
  702.       return_error(gs_error_limitcheck);
  703.     pdf_close_contents(pdev, false);
  704.     pdf_open_page(pdev, pdf_in_none);
  705.     info_id = pdf_begin_obj(pdev);
  706.     pputs(s, "<<\n");
  707.     for ( i = 0; i < count; i += 2 )
  708.       if ( !pdf_key_eq(&pairs[i], "CreationDate") &&
  709.            !pdf_key_eq(&pairs[i], "Producer")
  710.          )
  711.         pdfmark_write_pair(s, &pairs[i]);
  712.     pdf_write_default_info(pdev);
  713.     pputs(s, ">>\n");
  714.     pdf_end_obj(pdev);
  715.     pdev->info_id = info_id;
  716.     return 0;
  717. }
  718.  
  719. /* DOCVIEW pdfmark */
  720. private int
  721. pdfmark_DOCVIEW(gx_device_pdf *pdev, const gs_param_string *pairs, uint count,
  722.   const gs_matrix *pctm)
  723. {    char dest[max_dest_string];
  724.  
  725.     if ( pdfmark_make_dest(dest, pdev, pairs, count) )
  726.       { gs_param_string add_dest[2];
  727.         static const char *skip_dest[] = { "Page", "View", 0 };
  728.  
  729.         param_string_from_string(add_dest[0], "OpenAction");
  730.         param_string_from_string(add_dest[1], dest);
  731.         return pdfmark_save_edited_pairs(pdev, pairs, count, skip_dest,
  732.                          add_dest, 2,
  733.                          &pdev->catalog_string);
  734.       }
  735.     else
  736.       return pdfmark_save_pairs(pdev, pairs, count, &pdev->catalog_string);
  737. }
  738.